/**
 * 全局消息管理器
 * 统一管理应用中的消息弹框显示
 */

class MessageManager {
	constructor() {
		this.isShowing = false
		this.messageQueue = []
		this.currentMessage = null
		this.listeners = new Set()
		this.messageHistory = [] // 消息历史记录
		this.maxHistorySize = 100 // 最多保存100条历史消息
		this.loadMessageHistory() // 加载本地存储的消息历史
	}
	
	/**
	 * 显示消息弹框
	 * @param {Object} message 消息对象
	 * @param {Object} options 选项
	 */
	showMessage(message, options = {}) {
		const messageData = {
			id: this.generateId(),
			fromUser: message.fromUser || '系统消息',
			content: message.content || '',
			sendTime: message.sendTime || new Date().toISOString(),
			avatar: message.avatar || null,
			type: message.type || 'text', // text, image, system
			...options
		}
		
		// 如果当前有消息在显示，加入队列
		if (this.isShowing) {
			this.messageQueue.push(messageData)
			return
		}
		
		// 立即显示消息
		this.displayMessage(messageData)
	}
	
	/**
	 * 显示系统消息
	 * @param {String} content 消息内容
	 * @param {Object} options 选项
	 */
	showSystemMessage(content, options = {}) {
		this.showMessage({
			fromUser: '系统消息',
			content: content,
			type: 'system'
		}, options)
	}
	
	/**
	 * 显示AI助手消息
	 * @param {String} content 消息内容
	 * @param {Object} options 选项
	 */
	showAIMessage(content, options = {}) {
		this.showMessage({
			fromUser: 'AI智能助教',
			content: content,
			type: 'ai',
			avatar: '/static/ai-avatar.png'
		}, options)
	}

	/**
	 * 发送消息给AI助手并获取回复
	 * @param {String} message 用户消息
	 * @param {String} userId 用户ID（可选）
	 * @returns {Promise} AI回复Promise
	 */
	async sendToAI(message, userId = null) {
		try {
			// 动态导入AI API服务
			const aiApiModule = await import('./ai-api.js')
			const aiApiService = aiApiModule.default
			
			console.log('发送消息给AI:', message)
			
			// 调用AI API
			const response = await aiApiService.sendMessage(message, userId)
			
			if (response.success) {
				// 显示AI回复消息
				this.showAIMessage(response.content, {
					isAIReply: true,
					originalMessage: message,
					userId: response.user
				})
				
				return {
					success: true,
					content: response.content
				}
			} else {
				throw new Error('AI服务返回错误')
			}
		} catch (error) {
			console.error('AI消息发送失败:', error)
			
			// 显示错误提示
			this.showAIMessage(`抱歉，我暂时无法回复您的消息。错误：${error.message}`, {
				isError: true,
				originalMessage: message
			})
			
			return {
				success: false,
				error: error.message
			}
		}
	}

	/**
	 * 检查AI服务状态
	 * @returns {Promise} 服务状态
	 */
	async checkAIServiceStatus() {
		try {
			// 动态导入AI API服务
			const aiApiModule = await import('./ai-api.js')
			const aiApiService = aiApiModule.default
			
			const healthCheck = await aiApiService.checkHealth()
			
			if (healthCheck.success) {
				console.log('AI服务运行正常:', healthCheck.service)
				return { success: true, service: healthCheck.service }
			} else {
				console.warn('AI服务健康检查失败:', healthCheck.error)
				return { success: false, error: healthCheck.error }
			}
		} catch (error) {
			console.error('AI服务健康检查异常:', error)
			return { success: false, error: error.message }
		}
	}
	
	/**
	 * 显示作业相关消息
	 * @param {String} content 消息内容
	 * @param {Object} homework 作业信息
	 * @param {Object} options 选项
	 */
	showHomeworkMessage(content, homework = {}, options = {}) {
		this.showMessage({
			fromUser: homework.teacherName || '教师',
			content: content,
			type: 'homework',
			homeworkId: homework.id,
			...homework
		}, options)
	}
	
	/**
	 * 批量显示消息
	 * @param {Array} messages 消息列表
	 */
	showMessages(messages) {
		messages.forEach(message => {
			this.showMessage(message)
		})
	}
	
	/**
	 * 显示单个消息
	 * @param {Object} messageData 消息数据
	 */
	displayMessage(messageData) {
		this.isShowing = true
		this.currentMessage = messageData
		
		// 添加到消息历史
		this.addToHistory(messageData)
		
		// 通知所有监听器
		this.notifyListeners('show', messageData)
		
		console.log('显示消息弹框:', messageData)
	}
	
	/**
	 * 隐藏当前消息
	 */
	hideMessage() {
		this.isShowing = false
		this.currentMessage = null
		
		// 通知监听器
		this.notifyListeners('hide')
		
		// 显示队列中的下一个消息
		this.showNextMessage()
	}
	
	/**
	 * 显示队列中的下一个消息
	 */
	showNextMessage() {
		if (this.messageQueue.length > 0) {
			const nextMessage = this.messageQueue.shift()
			setTimeout(() => {
				this.displayMessage(nextMessage)
			}, 500) // 间隔500ms显示下一个
		}
	}
	
	/**
	 * 清空消息队列
	 */
	clearQueue() {
		this.messageQueue = []
	}
	
	/**
	 * 获取当前消息
	 */
	getCurrentMessage() {
		return this.currentMessage
	}
	
	/**
	 * 获取队列长度
	 */
	getQueueLength() {
		return this.messageQueue.length
	}
	
	/**
	 * 添加监听器
	 * @param {Function} listener 监听函数
	 */
	addListener(listener) {
		this.listeners.add(listener)
	}
	
	/**
	 * 移除监听器
	 * @param {Function} listener 监听函数
	 */
	removeListener(listener) {
		this.listeners.delete(listener)
	}
	
	/**
	 * 通知所有监听器
	 * @param {String} type 事件类型
	 * @param {Object} data 数据
	 */
	notifyListeners(type, data = null) {
		this.listeners.forEach(listener => {
			try {
				listener(type, data)
			} catch (error) {
				console.error('消息监听器执行错误:', error)
			}
		})
	}
	
	/**
	 * 生成唯一ID
	 */
	generateId() {
		return Date.now().toString(36) + Math.random().toString(36).substr(2)
	}
	
	/**
	 * 添加消息到历史记录
	 * @param {Object} messageData 消息数据
	 */
	addToHistory(messageData) {
		// 添加时间戳
		const historyItem = {
			...messageData,
			timestamp: new Date().toISOString(),
			displayTime: this.formatTime(new Date())
		}
		
		// 添加到历史记录开头
		this.messageHistory.unshift(historyItem)
		
		// 限制历史记录数量
		if (this.messageHistory.length > this.maxHistorySize) {
			this.messageHistory = this.messageHistory.slice(0, this.maxHistorySize)
		}
		
		// 保存到本地存储
		this.saveMessageHistory()
		
		console.log('消息已添加到历史记录:', historyItem)
	}
	
	/**
	 * 获取消息历史记录
	 * @param {Number} limit 限制数量
	 * @returns {Array} 消息历史列表
	 */
	getMessageHistory(limit = null) {
		if (limit && limit > 0) {
			return this.messageHistory.slice(0, limit)
		}
		return [...this.messageHistory]
	}
	
	/**
	 * 清空消息历史记录
	 */
	clearHistory() {
		this.messageHistory = []
		this.saveMessageHistory()
		console.log('消息历史记录已清空')
	}
	
	/**
	 * 保存消息历史到本地存储
	 */
	saveMessageHistory() {
		try {
			// 使用 uni.setStorageSync 保存到本地
			if (typeof uni !== 'undefined') {
				uni.setStorageSync('messageHistory', this.messageHistory)
			} else {
				// 浏览器环境使用 localStorage
				localStorage.setItem('messageHistory', JSON.stringify(this.messageHistory))
			}
		} catch (error) {
			console.error('保存消息历史失败:', error)
		}
	}
	
	/**
	 * 从本地存储加载消息历史
	 */
	loadMessageHistory() {
		try {
			let historyData = null
			
			// 尝试从 uni-app 存储加载
			if (typeof uni !== 'undefined') {
				historyData = uni.getStorageSync('messageHistory')
			} else {
				// 浏览器环境使用 localStorage
				const data = localStorage.getItem('messageHistory')
				if (data) {
					historyData = JSON.parse(data)
				}
			}
			
			if (historyData && Array.isArray(historyData)) {
				this.messageHistory = historyData
				console.log('已加载消息历史记录:', this.messageHistory.length, '条')
			}
		} catch (error) {
			console.error('加载消息历史失败:', error)
			this.messageHistory = []
		}
	}
	
	/**
	 * 格式化时间显示
	 * @param {Date} date 日期对象
	 * @returns {String} 格式化的时间字符串
	 */
	formatTime(date) {
		const now = new Date()
		const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
		const messageDate = new Date(date.getFullYear(), date.getMonth(), date.getDate())
		
		// 计算时间差
		const diffTime = today.getTime() - messageDate.getTime()
		const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24))
		
		const timeStr = date.toLocaleTimeString('zh-CN', { 
			hour: '2-digit', 
			minute: '2-digit',
			hour12: false
		})
		
		if (diffDays === 0) {
			return timeStr // 今天只显示时间
		} else if (diffDays === 1) {
			return `昨天 ${timeStr}`
		} else if (diffDays < 7) {
			return `${diffDays}天前 ${timeStr}`
		} else {
			return date.toLocaleDateString('zh-CN') + ' ' + timeStr
		}
	}
	
	/**
	 * 显示欢迎登录消息（特殊方法）
	 * @param {Object} userInfo 用户信息
	 */
	showWelcomeMessage(userInfo) {
		const currentHour = new Date().getHours()
		let timeGreeting = ''
		
		// 根据时间段显示不同的问候语
		if (currentHour >= 5 && currentHour < 12) {
			timeGreeting = '早上好'
		} else if (currentHour >= 12 && currentHour < 14) {
			timeGreeting = '中午好'
		} else if (currentHour >= 14 && currentHour < 18) {
			timeGreeting = '下午好'
		} else if (currentHour >= 18 && currentHour < 22) {
			timeGreeting = '晚上好'
		} else {
			timeGreeting = '夜深了'
		}
		
		// 获取用户名称
		const userName = userInfo.nickname || userInfo.name || userInfo.username || '同学'
		
		// 根据用户角色定制欢迎信息
		let roleInfo = ''
		if (userInfo.role === 'admin' || userInfo.role === 1) {
			roleInfo = '，祝您教学工作顺利！'
		} else {
			roleInfo = '，祝您学习愉快！'
		}
		
		// 组合完整的欢迎消息
		const welcomeMessage = `${timeGreeting}，${userName}！欢迎登录直播教育平台${roleInfo}`
		
		// 显示系统消息
		this.showSystemMessage(welcomeMessage, { 
			isWelcome: true,
			userInfo: userInfo
		})
		
		// 如果是夜深时分，额外提醒
		if (currentHour >= 22 || currentHour < 5) {
			setTimeout(() => {
				this.showSystemMessage('💤 夜深了，注意休息哦～')
			}, 4000)
		}
		
		// 如果是新用户（手机号登录），显示额外提示
		if (userInfo.phone && !userInfo.id) {
			setTimeout(() => {
				this.showSystemMessage('📝 建议您完善个人资料以获得更好的学习体验')
			}, 8000)
		}
	}
	
	/**
	 * 模拟接收新消息（用于测试）
	 */
	simulateMessage(type = 'random') {
		const mockMessages = {
			homework: {
				fromUser: '张教授',
				content: '您有新的作业需要完成：Java基础编程练习',
				type: 'homework'
			},
			system: {
				fromUser: '系统消息',
				content: '您的健康码状态已更新',
				type: 'system'
			},
			ai: {
				fromUser: 'AI助手',
				content: '我发现您还有3个作业即将到期，需要帮助吗？',
				type: 'ai'
			},
			classmate: {
				fromUser: '小明',
				content: '今天的数学作业你做了吗？',
				type: 'text'
			}
		}
		
		const messageType = type === 'random' 
			? Object.keys(mockMessages)[Math.floor(Math.random() * Object.keys(mockMessages).length)]
			: type
			
		this.showMessage(mockMessages[messageType] || mockMessages.system)
	}
}

// 创建全局实例
const messageManager = new MessageManager()

// 导出实例和类
export default messageManager
export { MessageManager }

	